package homework1_array.alg_21;

import static homework1_array.Utils.printList;

public class ArrayHomework {

    public static void main(String[] args) {

        //todo 作业1：完成这个测试方法中的addByElementBySequence()方法
	arrayAddTest();

        // todo 作业2：完成这个测试类中的removeByElement()方法
		// deleteTest();

    }

    /**
     * 在有序列表中插入元素
     */
    private static void arrayAddTest() {

        int[] arr = new int[20];
		arr[0] = 4;
		arr[1] = 7;
		arr[2] = 3;
        arr[3] = 8;
// 1.中间位置插入
        addByElementSequence(arr, 4, 6);
		printList("在有序数组的中间部分插入元素后的结果为：", arr, 5);
        //此时应输出 3 4 6 7 8

//2.尾部插入
		addByElementSequence(arr, 5, 9);
		printList("在有序数组的尾部插入元素后的结果为：", arr, 6);
        //此时应输出 3 4 6 7 8 9

//3.数组首部插入
		addByElementSequence(arr, 6, 1);
		printList("在有序数组的首部部分插入元素后的结果为：", arr, 7);
        //此时应输出：1 3 4 6 7 8 9

    }

    //todo 作业1：完成这个方法

    /**
     * @param arr     存储元素的数组
     * @param size    数组中已经存储的元素数量
     * @param element 要插入数组的新元素
     * @return
     */
    public static void addByElementSequence(int[] arr, int size, int element) {
		// 将新数据添加到新数组中
		arr[size] = element;
		// 使用冒泡排序对数据进行排序
		//generalOrder(arr, size);
		
		bubblingOrder(arr, size);
    }

    /**
     * 删除测试
     */
    private static void deleteTest() {
        int[] arr = new int[]{2, 3, 4, 9, 10, 11, 12};

//1.删除头元素
        removeByElement(arr, 7, 2);
        printList("删除头元素后的结果为：", arr, 6);
        //此时应该打印 3 4 9 10 11 12

//2. 删除尾元素
	removeByElement(arr, 6, 12);
	printList("删除尾元素的结果为：", arr, 5);
        //此时应该打印 3 4 9 10 11

//3. 删除中间元素：
        removeByElement(arr, 5, 9);
        printList("删除中间元素的结果为：", arr, 4);
        //此时应该打印 3 4 10 11
    }

    /**
     * 从数组中删除元素e
     *
     * @param arr
     * @param size 数组已经存放的元素大小
     * @param key  要删除的元素
     */
    public static void removeByElement(int[] arr, int size, int key) {
		// 计算删除元素的索引位置
		int index = -1;
		for (int i = 0; i < arr.length; i++) {
			if (arr[i] == key) {
				index = i;
				break;
			}
		}
		// 如果当前数组没有包含当前key，直接返回
		if (index == -1)
			return;
		// 根据匹配的索引位置重新构造新的数组
		// System.arraycopy(arr, index + 1, arr, index, size - (index + 1));
		for (int i = index; i < size - index - 1; i++) {
			arr[i] = arr[i + 1];
		}
    }

	/**
	 * bubbling 排序方式
	 * 
	 * @param arr
	 * @param size
	 */
	public static void bubblingOrder(int[] arr, int size) {
		// 总循环次数
		for (int i = 0; i <= size; i++) {
			// 每次循环要比较的次数
			for (int j = 0; j <= size - i - 1; j++) {
				if (arr[j] > arr[j + 1]) {
					int temp = arr[j];
					arr[j] = arr[j + 1];
					arr[j + 1] = temp;
				}
			}
			// System.out.println(String.format("第%d次排序结果:%s", i, Arrays.toString(arr)));
		}
	}

	/**
	 * for 排序方式
	 * 
	 * @param arr
	 * @param size
	 */
	public static void generalOrder(int[] arr, int size) {
		for (int i = 0; i <= size; i++) {
			for (int j = i + 1; j <= size; j++) {
				if (arr[i] > arr[j]) {
					int temp = arr[i];
					arr[i] = arr[j];
					arr[j] = temp;
				}
			}
			// System.out.println(String.format("第%d次排序结果:%s", i, Arrays.toString(arr)));
		}
	}

}
